home *** CD-ROM | disk | FTP | other *** search
/ Hardcore Gamer Resource Kit / Hardcore Gamer Resource Kit - Disc 3.iso / screensavers / saver17.zip / VoodooLights / Sources / cell.c < prev    next >
C/C++ Source or Header  |  1997-07-24  |  6KB  |  248 lines
  1. /*------------------------------------------------------/
  2. /                                                        /
  3. /    Copyright 1997, SΘrgio Durte <smd@di.fct.unl.pt>    /
  4. /                                                        /
  5. /------------------------------------------------------*/
  6.  
  7. #include <stdio.h>
  8. #include <glide.h>
  9.  
  10. #include "defines.h"
  11. #include "mat.h"
  12. #include "rgb.h"
  13. #include "tex.h"
  14. #include "cam.h"
  15. #include "cell.h"
  16. #include "cell_util.h"
  17. #include "cell_tp1.h"
  18. #include "cell_tp2.h"
  19. #include "cell_tp3.h"
  20. #include "cell_tp4.h"
  21. #include "cell_tp5.h"
  22. #include "cell_tp6.h"
  23. #include "cell_tp7.h"
  24. #include "cell_tp8.h"
  25. #include "cell_tp9.h"
  26. #include "cell_tp10.h"
  27.  
  28. #define MaxCellTypes    12
  29. #define MaxCells        2048
  30.  
  31. static    int tot_Cells = 0 ;
  32.  
  33. static    Cell cells[ MaxCells ] ;
  34.  
  35. struct {
  36.     int n ;
  37.     Cell *list[ MaxCells ] ;
  38.     void (*set_glide_state)( void ) ;
  39. } cells_by_type[ MaxCellTypes ] ;
  40.  
  41.  
  42. Cell **cell_get_cells_by_type( int type, int *n)
  43. {
  44.     *n = cells_by_type[ type ].n ;
  45.     return cells_by_type[ type ].list ;
  46. }
  47.  
  48. static Cell *cell_new_cell( int type )
  49. {
  50.     int i ;
  51.     Cell *c ;
  52.     
  53.     for( i = 0 ; i < MaxCells ; i++ )
  54.         if( cells[i].status == DEAD ) {
  55.             c = & cells[i] ;
  56.             break ;
  57.         }
  58.     cells_by_type[ type ].list[ cells_by_type[type].n++ ] = c ;
  59.  
  60.     return c ;
  61. }
  62.  
  63. // Isto Θ feio mas por agora fica assim
  64. static void cell_compute_cells_by_type( void )
  65. {
  66.     int i ;
  67.  
  68.     for( i = 0 ; i < MaxCellTypes ; i++ ) cells_by_type[i].n = 0 ;
  69.  
  70.     for( i = 0 ; i < MaxCells ; i++ ) {
  71.         Cell *c = & cells[i] ;
  72.         if( c->status == ALIVE ) 
  73.             cells_by_type[ c->type ].list[ cells_by_type[ c->type ].n++ ] = c ;        
  74.     }
  75. }
  76.  
  77. void cell_InitModule( void )
  78. {
  79.     int i ;
  80.     
  81.     for( i = 0 ; i < MaxCells ; i++ ) cells[i].status = DEAD ;
  82.     for( i = 0 ; i < MaxCellTypes ; i++ ) cells_by_type[i].n = 0 ;
  83.  
  84.     cells_by_type[ CellType1 ].set_glide_state = tp1_set_glide_state ;
  85.     cells_by_type[ CellType2 ].set_glide_state = tp2_set_glide_state ;
  86.     cells_by_type[ CellType3 ].set_glide_state = tp3_set_glide_state ;
  87.     cells_by_type[ CellType4 ].set_glide_state = tp4_set_glide_state ;
  88.     cells_by_type[ CellType5 ].set_glide_state = tp5_set_glide_state ;
  89.     cells_by_type[ CellType6 ].set_glide_state = tp6_set_glide_state ;
  90.     cells_by_type[ CellType7 ].set_glide_state = tp7_set_glide_state ;
  91.     cells_by_type[ CellType8 ].set_glide_state = tp8_set_glide_state ;
  92.     cells_by_type[ CellType9 ].set_glide_state = tp9_set_glide_state ;
  93.     cells_by_type[ CellType10 ].set_glide_state  = tp10_set_glide_state ;
  94.  
  95.     tot_Cells = 0 ;
  96.  
  97.     for( i = 0 ; i < 7 ; i++ ) ctp1_Constructor( NULL ) ;    
  98.     for( i = 0 ; i < 100 ; i++ ) ctp6_Constructor( NULL ) ;    
  99.  
  100.     for( i = 0 ; i < 3 ; i++ ) ctp2_Constructor( NULL ) ;    
  101.   
  102.     for( i = 0 ; i < 2 ; i++ ) ctp5_Constructor( NULL ) ;    
  103.  
  104.     for( i = 0 ; i < 2 ; i++ ) ctp8_Constructor( NULL ) ;    
  105.     
  106.     ctp10_Constructor( NULL ) ;    // tφtulo.
  107.  
  108. }
  109.  
  110.  
  111. void cell_MainLoop( void )
  112. {
  113.     int j ;
  114.  
  115.  
  116.     for( j = 1 ; j <= CellType10 ; j++ ) {
  117.         int i ;
  118.         cells_by_type[ j ].set_glide_state() ;
  119.  
  120.         for( i = 0 ; i < cells_by_type[ j ].n ; i++ ) {
  121.                 Cell *c = cells_by_type[ j ].list[i] ;
  122.                 c->display_cell( c ) ;
  123.         }
  124.     }
  125.  
  126.     // tratar dos vßrios aspectos da vida das cΘlulas
  127.     for(j = MaxCells ; j >= 0 ; j-- ) 
  128.         if( cells[j].status == ALIVE ) {
  129.             cells[j].move_cell( cells + j ) ;
  130.             cells[j].acc_cell( cells + j ) ;
  131.             cells[j].reproduce_cell( cells + j ) ;
  132.             cells[j].age_cell( cells + j ) ;
  133.         
  134.         }
  135.     // apagar as cΘlulas que morreram no passo anterior
  136.     for( j = 0 ; j < MaxCells ; j++ )
  137.         if( cells[j].status == DYING ) cells[j].status = DEAD ;
  138.  
  139.     cell_compute_cells_by_type() ;
  140.  
  141. }
  142.  
  143. void cell_menopause( Cell *c )
  144. {
  145. }
  146.  
  147. static void cell_move_cell( Cell *c )
  148. {
  149.     mat_combv( dt, & c->vel, & c->pos, & c->pos ) ;
  150.     mat_combv( dt, & c->acc, & c->vel, & c->vel ) ;
  151.     cutl_limit_speed( c, c->max_speed ) ;
  152. }
  153.  
  154. static void cell_acc_cell(Cell *c) 
  155. {  
  156.     c->acc = xyz_Zero ;   
  157. }
  158.  
  159. static void cell_age_cell(Cell *c)
  160. {
  161.   if( c->age < c->adulthood ) c->age += dt ;
  162. }
  163.  
  164. static void cell_reproduce_cell( Cell *c) 
  165. {
  166. }
  167.  
  168. static void cell_display_cell( Cell *c )
  169. {
  170.     int n ;
  171.     XYZ pos, p ;
  172.     XYZWRGBAST p0, p1, p2, p3 ;
  173.     RGBA color ;
  174.     Vector *v[10] ;
  175.  
  176.     cam_W2C_XYZ( & c->pos, & pos ) ; 
  177.     
  178.     p.x = pos.x - c->size ;
  179.     p.y = pos.y + c->size ;
  180.     p.z = pos.z ;
  181.  
  182.     cam_C2P_XYZ( & p, (XYZW *)& p0 ) ;
  183.     p.y = pos.y - c->size ;    
  184.     cam_C2P_XYZ( & p, (XYZW *)& p1 ) ;
  185.     p.x = pos.x + c->size ;
  186.     cam_C2P_XYZ( & p, (XYZW *)& p2 ) ;
  187.     p.y = pos.y + c->size ;    
  188.     cam_C2P_XYZ( & p, (XYZW *)& p3 ) ;
  189.  
  190.     p0.s = 0.0 ; p0.t = 0.0 ;
  191.     p1.s = 0.0 ; p1.t = 255.0 ;
  192.     p2.s = 255.0 ; p2.t = 255.0 ;
  193.     p3.s = 255.0 ; p3.t = 0.0 ;
  194.  
  195.     color = c->color ;
  196.     c->sparkle += c->sparkle_range * (1.0 - 2.0 * rnd()) ;
  197.     c->sparkle = max( c->sparkle_min, min( 1.0, c->sparkle ) ) ;
  198.  
  199.     color.r = c->color.r * c->sparkle ;
  200.     color.g = c->color.g * c->sparkle ;
  201.     color.b = c->color.b * c->sparkle ;
  202.     color.a = c->color.a ;
  203.  
  204.     bcopy( & color, (RGBA *) & p0.r, sizeof( RGBA ) ) ;
  205.     bcopy( & color, (RGBA *) & p1.r, sizeof( RGBA ) ) ;
  206.     bcopy( & color, (RGBA *) & p2.r, sizeof( RGBA ) ) ;
  207.     bcopy( & color, (RGBA *) & p3.r, sizeof( RGBA ) ) ;
  208.  
  209.     v[0] = (Vector *) & p0 ;
  210.     v[1] = (Vector *) & p1 ;
  211.     v[2] = (Vector *) & p2 ;
  212.     v[3] = (Vector *) & p3 ;
  213.     
  214.     clp_ClipPolygonRef( 10, 4, v, & n, v ) ;
  215.  
  216. }
  217.  
  218. Cell *cell_Constructor( int type )
  219. {
  220.     
  221.     Cell *c = cell_new_cell( type ) ;
  222.     c->type = type ;
  223.  
  224.     c->status = ALIVE ;
  225.     c->age = 1.0 ;
  226.     c->acc = xyz_Zero ;
  227.     c->vel = xyz_Zero ;
  228.     c->max_speed = 1e8 ;
  229.     c->n_chld = 0 ;
  230.     c->generation = 1 ;
  231.     c->sparkle = 1.0 ;
  232.     c->sparkle_range = 0.2 ;
  233.     c->sparkle_min = 0.6 ;
  234.  
  235.     c->move_cell = cell_move_cell ;
  236.     c->acc_cell = cell_acc_cell ;
  237.     c->age_cell = cell_age_cell ;
  238.     c->reproduce_cell = cell_reproduce_cell ;
  239.     c->display_cell = cell_display_cell ;
  240.  
  241.     return c ;
  242. }
  243.  
  244. void cell_Destructor( Cell *c )
  245. {
  246.     c->status = DEAD ; // ainda Θ preciso ver se deve ser DYING...
  247. }
  248.